Dynamic record blocking

ABSTRACT

Dynamic blocking determines which pairs of records in a data set should be examined as potential duplicates. Records are grouped together into blocks by shared properties that are indicators of duplication. Blocks that are too large to be efficiently processed are further subdivided by other properties chosen in a data-driven way. We demonstrate the viability of this algorithm for large data sets. We have scaled this system up to work on billions of records on an 80 node Hadoop cluster.

CROSS-REFERENCES TO RELATED APPLICATIONS

This application claims the benefit of priority from provisional application No. 61/582,775 filed Jan. 3, 2012, the content of which is incorporated herein by reference.

STATEMENT REGARDING FEDERALLY SPONSORED RESEARCH OR DEVELOPMENT

N/A

FIELD

The technology herein relates to automatic data processing, and more particularly to database management and deduplication. Still more particularly, the technology herein relates to dynamic blocking, which determines which pairs of records in a data set should be examined as potential duplicates, and to scalable blocking techniques for duplicate record detection that operate on the intuitive notion of grouping together records with similar properties and then subdividing the groups using other shared properties until they are all of tractable size.

BACKGROUND AND SUMMARY

A challenge for builders of databases whose information is culled from multiple sources is the detection of duplicates, where a single real-world entity gives rise to multiple records. For example, online citation indexes need to be able to navigate the different capitalization and abbreviation conventions that appear in bibliographic entries; government agencies need to know whether a record for “Robert Smith” living on “Northwest First Street” refers to the same person as one for a “Bob Smith” living on “1st St. NW”; and consumers need to know whether publicly available records correspond to the same or different entity. This problem becomes more significant as the amount of readily available information continues to increase.

A standard machine learning approach to this problem is to train a model that assigns scores to pairs of records where pairs scoring above a threshold are said to represent the same entity. Transitive closure is then performed on this same-entity relationship to find the sets of duplicate records. Comparing all pairs of records is quadratic in the number of records and so therefore is intractable for large data sets. In practice, using an approach called “blocking”, only a subset of the possible pairs is referred to the machine learning component and others are assumed to represent different entities. So a “Robert Smith“−”Bob Smith” record pair may be scored while a “Robert Smith“−”Barack Obama” pair is dismissed. This risks a false negative error for the system if the “Robert Smith” and “Barack Obama” records do in fact refer to the same person, but in exchange for this the system runs faster.

The term of art for this process is blocking because it groups similar-seeming records into blocks that a pairwise decision making component (a component which might use either a machine learning or a deterministic technique to determine whether the pair of records should in fact be linked) then explores exhaustively. A common technique of published blocking algorithms is the general strategy of quickly identifying a set of record pairs to pass along to a linkage component.

Previous work relevant to blocking is known. See e.g., A. K. Elmagarmid, P. G. Iperirotis and V. S. Verykios, “Duplicate Record Detection: A Survey,” IEEE Transactions on Knowledge and Data Engineering, pages 1-16, 2007; A. Borthwick, A. Goldberg, P. Cheung and A. Winkel, “Batch Automated Blocking And Record Matching,” 2005, U.S. Pat. No. 7,899,796; A. McCallum, K. Nigam and L. H. Ungar, “Efficient Clustering Of High-Dimensional Data Sets With Application To Reference Matching,” Proceedings of the ACM International Conference on Knowledge Discover and Data Mining, pages 169-178, 2000); M. A. Hernandez and S. J. Stolfo, “Real-world data is dirty, data cleansing and the merge/purge problem,” Journal of Data Mining and Knowledge Discovery (pages 1-39, 1998). However, additional improvements are possible and desirable.

We describe herein a novel blocking technique for duplicate record detection that operates on the intuitive notion of grouping together records with similar properties and then subdividing the groups using other shared properties until they are all of tractable size. A non-limiting example implementation in the MapReduce framework provides parallel computing that may scale to inputs in the billions of records. We call our overall non-limiting technique dynamic blocking because the blocking criteria adjust in response to the composition of the data set. We want blocking to be a mechanical automatically implemented process, not an art.

One example non-limiting blocking strategy is used to deploy a massive database of personal information for an online people search. This database distills a heterogeneous collection of publicly available data about people into coherent searchable profiles. This distillation process can be framed as a duplicate detection task. We have developed a non-limiting novel blocking procedure that in addition to the standard performance/recall tradeoff is tailored to 1) scale to very large data sets and 2) robustly handle novel data sources. Scaling to very large data sets is useful because we map billions of input records to hundreds of millions of people in the real world. This is possible with distributed computing, and the ability to distribute the work informs the design. Robustly handling diverse data sources is useful because we are acquiring new and diverse sources of information all the time, so the hand-crafting of the blocking procedure by experts can become a bottleneck.

Additional example non-limiting dynamic blocking features and/or advantages of exemplary non-limiting implementations include:

-   -   Extending known blocking algorithms in significant and         non-obvious ways     -   Adapting blocking algorithms to run in a scalable, distributed         computing environment     -   Adding a ramp factor for more efficient extraction of the         sub-block space     -   In common with many known blocking systems, using a general         strategy of quickly identifying a set of record pairs to pass         along to a linkage component     -   Particular advantageous ways to construct sets and handle         oversized sets     -   Use of known strategy of allowing sets of records to overlap in         a new context     -   Can be applied to data sets when there is no obvious         quickly-calculable metric between records and the number of         records makes even a fast calculation for all pairs intractable     -   Create multiple top-level blocks that can be worked on         independently     -   As records have several property dimensions along which they may         vary, no need to try to define a single ordering that places         similar records next to each other.     -   We allow the maximum block size to be a function of the block         key length.     -   This blocking procedure incorporates innovations necessary to         make it work on data sets containing billions of records.     -   The entire system from start to finish including the blocking         component that is the focus of this patent can be run in         parallel across a distributed cluster of computers.     -   The blocking algorithm can handle arbitrarily large input record         blocks.     -   Example non-limiting system can be implemented using the         MapReduce distributed computing framework.     -   Pair deduplication and text normalization (while I/O constraints         of working with large data sets may prevent a straightforward         deduplication of all pairs, a suitable algorithm can perform         this deduplication without incurring the I/O costs)     -   One non-limiting arrangement may directly address errors in the         original data, relying instead on multiple top-level keys to         catch mis-blockings due to typos, but there is also a         possibility to implement text normalization for our system.     -   Additional record properties such as, for example, Soundex         versions of text fields.     -   Use of pair mechanism to discover relationship between entities.

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features and advantages will be better and more completely understood by referring to the following detailed description of exemplary non-limiting illustrative embodiments in conjunction with the drawings of which:

FIG. 1 is a block diagram of an example non-limiting system;

FIG. 2 is an exemplary illustrative non-limiting tree for the oversize top-level set “Smith” wherein the root node of this tree represents an oversized block for the name Smith and the other nodes represent possible sub-blocks; the sub-blocking algorithm enumerates the tree breadth-first, stopping when it finds a correctly-sized sub-block;

FIG. 3 is an exemplary illustrative non-limiting recursive blocking algorithm;

FIG. 4 is a block diagram of an example non-limiting dynamic blocking and deduplication algorithm;

FIG. 5 is an exemplary illustrative non-limiting iterative MapReduce block algorithm;

FIGS. 6A and 6B are exemplary illustrative non-limiting graphs showing compression for different blocking parameters wherein FIG. 6A directly shows compression as a function of the max block size and ramp parameters and FIG. 6B shows compression as a function of the number of unique pairs in the blocks;

FIG. 7 is an exemplary illustrative non-limiting graph showing the number of correct-sized blocks discovered in each iteration for max block size 300;

FIGS. 8-10 show overview of an exemplary illustrative non-limiting MapReduce implementation of the blocking algorithm;

FIG. 11 shows an example non-limiting conventional MapReduce architecture; and

FIG. 12 shows an example non-limiting Hadoop cluster architecture.

DETAILED DESCRIPTION OF NON-LIMITING EXAMPLES Example Non-Limiting System Overview

As shown in FIG. 1, raw input to the example non-limiting system 100 described herein consists of publicly available or other personal identification information such as for example name, address, birthday, phone number, and (encrypted) social security number about people in the United States or elsewhere culled from various sources. The record deduplication system 100 has four major components: 1) data cleaning 110, 2) blocking and deduplication 120, 3) linkage 130, and 4) transitive closure 140.

The data cleaning step 110 extracts information from a wide variety of sources and puts it into a uniform record format. It also performs a variety of normalization tasks such as text cleanup and name and address parsing. The linkage step 130 assigns a score to pairs of records using a machine learning model such as described e.g. in S. Chen, A. Borthwick, and V. R. Carvalho, “The Case For Cost-Sensitive And Easy-To-Interpret Models In Industrial Record Linkage,” 9th International Workshop on Quality in Databases, August 2011, incorporated herein by reference. If a pair scores above a threshold, the records are presumed to represent the same person. The transitive closure step 140 uses a distributed version of the union-find algorithm to combine record pairs into connected components. See e.g. http://chasebradford.wordpress.com/2010/10/23/mapreduce-implementation-for-union-find/. The system 100 partitions the input records into disjoint sets called profiles, where each profile corresponds to a single person. The example non-limiting dynamic blocking and deduplication step 120 is described in detail below.

Though the canonical task of one example non-limiting linkage component 130 is to find sets of records that represent the same entity, it is possible to create linkage components that discover other kinds of relationships. More generally, the linkage component may be thought of as a relationship detection component, where belonging-to-the-same-entity is particular kind of relationship. The procedure described herein can be used to block records for these general relationship detection linkage components. For example, we have used this system to create blocks of records that are fed to a linkage component that determines whether a pair of records represent two different people who are related. Other linkage applications and record relationships are also possible.

Dynamic Blocking 120: Blocks and Sub-Blocks

How might we subdivide a huge number of records? We could start by grouping them into sets of the same first and last name. This would go a long way towards putting together records that represent the same person, but it would still be imperfect because people may have nicknames or change their names. To enhance this grouping, we could consider a different kind of information such as social security number. Fraud, error, and omission render SSN imperfectly individuating; however, it will still help us put together records for, say, people who change their name when they get married. We only need a handful of these domain-specific properties to nicely subdivide our data set. The blocks of records they produce may overlap, but this is desirable because it gives transitive closure a chance to join records that blocking did not put together.

These blocks will vary widely in size. We may have a small set of “Barack Obama” records which can then be passed along immediately to the linkage component 130. However, we may have a set of millions of “Robert Smith” records which still needs to be cut down to size. One way to do this is to find other properties to further subdivide this set. The set of all Robert Smiths who have the same middle name is smaller than the set of all Robert Smiths, and intuitively records in this set will be more likely to represent the same person. Additionally, we could block together all the Robert Smiths with the same phone number, or birthday, or who live in the same city. As with the original blocks, overlap between these sub-blocks is desirable. We do not have to be particularly artful in our choice of sub-blocking criteria: any property that seems like it might be individuating will do. As long as we have an efficient way to search the space, we can let the data dynamically choose different sub-blocking strategies for each oversize block.

More formally, this process can be understood in terms of operations on sets. In a set of N records there are ½ N (N−1) unique pairs, so an enumeration over all of them is O(N²). The process of blocking divides this original set into k blocks, each of which contains at most a fixed maximum of M records. The exhaustive comparison of pairs from these sets is O(kM²), and the quadratic factor is tractable if we choose a small enough M.

Call the elements in these sets records. An individual record can be thought of as a set of properties, where a property maps a schema (e.g. City or First Name) to a value (e.g. Seattle or Robert). In practice it may be useful to think of properties as functions of the fields actually present in the record. For example, a record may contain separate entries for first and last name but we may prefer to work with a property that is a combination of the two. Or a record may contain a phone number, but we may prefer to work with a property that is just the first three digits. It is possible to define a total ordering on properties. For instance, we can alphabetize them. One non-limiting approach: define a block to be a set of records that share one or more properties in common and represent blocks as tuples of the form (block key, records) where records is the set of records in the block and block key is the set of properties those records have in common. A block key is a unique informative name of a set of records. Blocks whose keys contain multiple properties are the intersections of the blocks who have those individual properties as keys. If we have a total orderings of properties we can define a total ordering on block keys by sorting them lexicographically by property.

In one non-limiting approach, we select a small number of top level properties such as name and social security number to do the initial blocking, and a broader set of sub-blocking properties which are used to subdivide oversized sets (see FIG. 4 item 150). The latter may be a superset of the former. Blocks whose keys consist of a single top-level property are called top-level blocks and blocks that are the result of further subdivision are called sub-blocks.

The algorithm that creates the blocks and sub-blocks takes as input a set of records and a maximum block size M. All the input records are grouped into blocks defined by the top-level properties. Those top-level blocks that are not above the maximum size are set aside. The remaining oversized blocks are partitioned into sub-blocks by sub-blocking properties that the records they contain share, and those properties are appended to the key. The process is continued recursively or iteratively until all sub-blocks have been whittled down to an acceptable size.

The records in a given block will contain a set of sub-blocking properties, and a complete enumeration of the possible sub-blocks requires enumerating the power set of this property set—intersecting the same-birthday sets with the same-phone number sets and intersecting all those with the same-city sets and so forth. We need an efficient way to conduct this exploration, bailing out as soon as possible. To this end, we use the ordering on block keys to define a binomial tree where each node contains a list of block keys and is the parent of nodes that have keys that come later in the ordering appended to the list.

FIG. 2 shows an example non-limiting tree for the oversize top-level set Smith with sub-block keys for birth year 1971<first name Robert<city Seattle. With each node of the tree, we can associate a block whose key is the list of blocks keys in that node and whose records are the intersection of the records in those blocks, e.g. the Smith ∩1971∩ Seattle node represents all the records for people named Smith who were born in 1971 and live in Seattle. Because the cardinality of an intersected set is less than or equal to the cardinalities of the sets that were intersected, every block in the tree is larger than or equal to any of its children. We traverse the tree breadth-first and only recurse into nodes above the maximum block size. This allows us to explore the space of possible sub-blocks in cardinality order for a given branch, stopping as soon as we have a small enough sub-block.

FIG. 3 shows example non-limiting pseudo-code of a dynamic Block function that performs blocking using a recursive algorithm (another example non-limiting implementation using a Hadoop version of the algorithm is discussed below in connection with FIG. 5).

In FIG. 3, the Block function creates the top-level blocks and each call to the Sub-Block function enumerates one level deeper into the tree. The Oversize function determines if the block is over the maximum size, which in our system is expressed in terms of the maximum number of pairs a block may contain. There is also an additional condition to ignore blocks of size 1 since these will not contain any pairs. Note that we do not know all the sub-block keys that will be present in a given set of records a priori. Instead the algorithm discovers this set as it runs.

In the worst case, all the sub-blocks except the ones with the very longest keys are oversize. Then the sub-blocking algorithm will explore the power-set of all possible blocking keys and thus have exponential runtime. However, as the block keys get longer the sets they represent get smaller and eventually fall beneath the maximum size. In practice these two countervailing motions work to keep this strategy tractable. As will be shown in the experiments, the bulk of the sub-blocks have key lengths of 3 or less.

Scalability Through Parallel (e.g., Cloud based) Computing

In one example non-limiting implementation, the volume of data involved suggests that system 100 be distributed across a cluster of machines. In our example non-limiting implementation, we make heavy use of the conventional Hadoop implementation (see FIG. 12) of the conventional MapReduce computing framework (see FIG. 11). MapReduce is a standard distributed computing framework, as those skilled in the art will understand. Nothing in our example non-limiting implementation is limited to MapReduce per se, but our example non-limiting design accommodates the MapReduce constraint that the components running in parallel do not share memory. Below we discuss the ways constraints of the MapReduce computing framework inform our non-limiting example design implementation. The example non-limiting detailed design presented herein would be appropriate for any MapReduce-like distributed computing environment that imposed this constraint, and other non-limiting implementations could use other parallel processing arrangements.

Thus, the example non-limiting blocking procedure described here is implemented as a series of Hadoop jobs written in Java. For a full description of the conventional MapReduce framework, see J. Lin and C. Dyer, Data-Intensive Text Processing with MapReduce, Synthesis Lectures on Human Language Technologies (Morgan & Claypool, 2010), from which FIGS. 11 & 12 were taken. As shown in FIG. 11, MapReduce divides computing tasks into a map or mapper phase in which the job is split up among multiple machines to be worked on in parallel and a reduce or reducer phase in which the output of the map phase is put back together. In a MapReduce context, recursion becomes iteration. A single MapReduce iteration works down one level of the binomial tree of sub-block intersections.

The ability to handle arbitrarily large input record blocks is an element of scalability. Suppose we (quite sensibly) wanted to block together all records containing the same first and last names. Some names like “Robert Smith” will be very common. It will be impossible to fit all the “Robert Smith” records in memory at the same time. Our system addresses this with the BLOCKING-REDUCER algorithm. In that algorithm we examine the records in a block one at a time, accumulating them in an in-memory buffer. However, if the block is oversized we will not accumulate all the records in the buffer. Instead as soon as the buffer contains more than the maximum number of records allowed in a block, we flush its contents to the oversized blocks destination, and then immediately send all subsequent records to that destination as well. Even if we are working on a huge oversized block like all the “Robert Smith” records, we only require enough memory to store a single correct-sized block. In computer science terms, the memory requirements of the BLOCKING-REDUCER algorithm are constant.

In order to enable a constant-memory BLOCKING-REDUCER algorithm, we construct blocking as an iterative process, writing oversized blocks to disk between each iteration. This trades the I/O for these disk writes for an assurance that we can handle arbitrarily large blocks. Our system also enables us to make a different trade-off on a block-by-block basis. Optionally, you may specify an in-memory blocking threshold. Blocks with a size above this threshold are handled iteratively in the manner described above. Blocks smaller than that threshold are sub-blocked entirely in memory. The sub-blocking algorithm is exactly the same, but intermediary sets of oversized blocks are stored in memory instead of being written to disk. This enables our system to achieve higher performance on smaller blocks that we know will fit in memory.

FIG. 5 shows example pseudo-code of a non-limiting MapReduce version of the sub-blocking algorithm. The mapper functions parallelize the extraction of properties from records performed in the loops beginning in lines Block Line 3 and Sub-Block Line 6 in the recursive blocking algorithm in FIG. 3. The Top-Level-Mapper is run on the first iteration and the Sub-Block-Mapper is run subsequently (see also FIG. 4 item 150). The reducer function enumerates over all the records in a newly-created sub-block, counting them to determine whether or not the block is small enough or needs to be further subdivided. The blocks the reducer deems oversized become inputs to the next iteration. Care is taken that the memory requirements of the reducer function are constant in the size of a fixed buffer because otherwise the reducer runs out of memory on large blocks. Also note that the lexicographic ordering of the block keys allows separate mapper processes to work on different nodes in a level of the binomial tree without creating redundant sub-blocks (e.g. if one mapper creates a Robert ∩Seattle block another mapper will not create a Seattle∩Robert one). This is desirable because individual MapReduce jobs run independently without shared memory or other runtime communication mechanisms.

As we have noted, it is desirable in one example non-limiting implementation to have overlapping blocks. The sub-blocking algorithm will create these, but it will also create redundant work for the linkage component by putting the same pairs of record in multiple blocks. Ideally, the set of pairs would be completely deduplicated, however, doing this incurs an I/O cost. Consider a single record that appears in a block with ten other records. If that block is passed to the linkage component as a whole the record is copied once, whereas if the block is exploded out into its pairs, the same record will be copied nine times. In our example non-limiting system, we have found that this I/O cost cancels out any efficiency gained by eliminating redundant work in the linkage component. We found it most effective to do block-level redundancy elimination. Starting from the output of sub-blocking, we run a MapReduce job that does block deduplication (see FIG. 4 item 160), so that when the same set of records appears with multiple block keys we only save one. The output of this is fed into another MapReduce process that groups together all the sub-blocks that have the same top-level key and only retains those sub-blocks that are not proper subsets of another sub-block. In our example non-limiting implementation, we performed this subset elimination using a version of the algorithm described e.g. in P. Pritchard, “A Simple Sub-Quadratic Algorithm For Computing The Subset Partial Order,” Information Processing Letters, 56(6):337-341, 1995, but note that subset elimination is an active area of research and there are multiple other algorithms that could be used. See FIG. 4 item 170 (“Subset Elimination”).

Additional Dynamic Blocking Features

We have developed two enhancements to the core algorithm described above: ramp and partitioned blocking. In terms of the algorithm expressed above both these features are implemented inside the Oversize function.

For performance reasons, we would like to minimize the amount of sub-blocking iterations we perform on a given set of input records. The longer a sub-block's key, the more properties its records have in common and intuitively the more likely it is that they will represent the same entity. We would be willing for the linkage component to do more work on these blocks, so our system has an optional ramp, a constant factor by which the maximum number of comparisons in a block is increased with each iteration. The ramp parameter gives us a data-driven way to trade off between sub-blocking and linkage work.

In some systems, we may wish to perform incremental linkage. We may receive data at separate times and wish to link new records to profiles generated by an earlier run. When doing this we need to compare new records to new records and new records to profiles, but we do not need to compare profiles to profiles because the linkage system has already deemed these to represent separate entities. Our example non-limiting system allows us to annotate records as belonging to mutually exclusive partitions. These partition annotations serve as instructions for the linkage component to only compare certain pairs in a block. Blocking supports this functionality by being aware of the partition annotations and calculating the number of comparisons present in a block accordingly.

More Detailed Non-Limiting Implementation Example

FIGS. 4, 8-10 give an overview of the example MapReduce implementation of the blocking algorithm, FIGS. 11 and 12 show an example MapReduce architecture that the blocking algorithm can run on, and FIGS. 6A, 6B and 7 show example results.

The FIG. 8 Iterative Process diagram shows an overview of the entire example non-limiting process. It illustrates that blocking 120 takes a set of records as input and groups them into blocks iteratively. Each iteration produces sub-blocks which can be either correct sized or oversized. The first iteration is called “Top Level Blocking” 210. The oversized sub-blocks 220 produced by top-level blocking 210 are passed into the first “Sub-Blocking” iteration 230. Oversized sub-blocks 240 produced by sub-blocking 230 are passed into subsequent sub-blocking iterations (250). Correct-sized blocks 260 produced by any iteration go into a separate collection that is passed along to the linkage component 130.

The FIG. 9 “Top Level MapReduce” diagram shows the process in the “Top-Level Blocking” 210 of the FIG. 8 “Iterative Process” in more detail. Likewise, the FIG. 10 “Sub-Blocking MapReduce” diagram shows more detail of the “Sub-Blocking” 230 of the FIG. 8 “Iterative Process”. Unlike “Iterative Process”, these diagrams illustrate the way the algorithm fits into the MapReduce framework.

“Top Level Map Reduce” 210 shows a set of Records 310 as input. These are passed to a variable number of “Top-Level Mapper” processes 320 running in parallel. (There are three of these boxes in the picture, but they represent an arbitrary number.) Each mapper process 320 corresponds to the TOP-LEVEL-MAPPER algorithm. The output of each mapper 320 is a set of <key, record> pairs 330. The MapReduce framework collects all these pairs, groups them by key, and sends them along to “Blocking Reducer” processes 340. Each of these boxes corresponds to the BLOCKING-REDUCER algorithm. (Again, there may be an arbitrary number, though three are shown here.) Each reducer divides the blocks up into correct size 350 and oversized 360 sets, and the MapReduce framework compiles the output for further processing.

“Sub-Blocking MapReduce” 230 is an almost identical diagram. The only differences are that the input is now a set of oversize blocks 410, the mappers are “Sub-Blocking Mapper” processes 420, and there is an arrow from the “Oversize Blocks” 460 output leading back to the input, indicating that this process repeats as many times as necessary. The mappers 420 in this diagram correspond to the SUB-BLOCK-MAPPER algorithm. The reducer algorithm for the Blocking Reducers 440 is the same as in the “Top Level Map Reduce” diagram.

FIG. 11 shows the general architecture of mappers and reducers running in parallel, mappers producing output in the form of ordered pairs, and the pairs being routed to reducers according to their key values, as is all standard to conventional MapReduce computing. One can readily see how the algorithms of FIGS. 9 and 10 can be implemented using the conventional MapReduce architecture of FIG. 11, where the top level mapper 320 or the sub-blocking mapper 420 are implemented by the MapReduce “mapper”, the MapReduce combiner and partitioners can be used to implement functionality associated with the <key, record> pairs 330, 430, and MapReduce's shuffle and sort is used to distribute pairs to MapReduce reducers that implement the Blocking Reducers 340, 440.

FIG. 12 shows an example non-limiting conventional architecture of a complete Hadoop cluster that can be used to implement FIGS. 9, 10. Such an example non-limiting architecture includes a namenode and a job submission node that support any number of distributed slave computing nodes each comprising a tasktracker and a datanode daemon. Each slave computing node can be implemented using a processor running Linux or other file system and coupled to a non-transitory storage device. The processor in each slave computing node can execute software stored on the non-transitory storage device, such software including the tasktracker and the datanode daemon, which communicate with the namenode and the jobsubmission node to provide distributed parallel processing e.g., in the cloud. Such parallel computing provides scaleability to allow to exemplary illustrative non-limiting implementation to quickly perform dynamic blocking on billions or any other arbitrarily large number of records.

Example Results

We present non-limiting examples that demonstrate the viability of this technique. These examples vary the blocking parameters maximum block size and ramp in runs over a small subset of our production data.

We ran these examples on 5,680,599 records sampled from a full data set of approximately 8 billion. To build this sample, we used all records that contained a first-last name pair that appeared on a list of 262,005 such pairs randomly chosen from the data set. We did name-based sampling instead of random sampling because the vast majority of record pairs in the full data set are not matches. By choosing a broadly individuating property like first and last name, we chose a set of records that will have more matches, focusing these experiments on a region of the problem space where blocking is having an effect.

We chose a sample of this size because we wanted to demonstrate our system's performance at scale. (Though it should be noted this is still a tiny fraction of the actual number of records that may be used in production.) There are approximately 10¹² record pairs in this dataset, making it infeasible to construct a hand-annotated reference set. However, when the linkage model is held constant, blocking does not change the score it assigns to any individual pair, only the number of pairs presented to it. In other words, blocking only affects recall, not precision. For these experiments, then, we treat the results returned by the linkage component as truth. If the model returns a score above a certain threshold (the same as the one we use in production), we treat the pair as a true positive. Otherwise we treat it as a true negative. This process may still lead to false positives, but that is a precision error, the fault of the linkage component 130, not blocking 120 whose job is solely to present the model with the record pairs it will tend to score the highest. We define the compression metric:

$\begin{matrix} {c = {1 - {\frac{{output}\mspace{14mu} {entities}}{{input}\mspace{14mu} {records}}.}}} & (1) \end{matrix}$

We present compression as a percentage. Given 8 billion records, we want to get out something around 275 million entities, because that is roughly the number of adults who have lives in the United States over the last 15 years, including people who have died or emigrated over that span. The higher the compression, the better. As a metric for the full system this isn't going to work, because it does not take precision into account; however, as long as the model is doing something reasonable, compression is a good proxy for recall.

We ran blocking 120, linkage 130, and transitive closure 140 on this sample of data for a range of maximum block size and ramp parameters. We used three top level properties: 1) first and last name, 2) social security number and 3) a tuple of last name, zip code, and house number. We used various sub-properties including various kinds of name and address information. The maximum block size ranged from 100 comparisons to 1000 comparisons, though of course the size of the individual blocks varied. The ramp ranged over various values from 0 to 5.

Table 1 below shows the compression for these parameters. The compression goes up monotonically with maximum block size and ramp. This is to be expected because increasing either of these two parameters increases the number of pairs that will be considered by the linkage component.

TABLE 1 Table of compression versus block size. 100 200 300 400 500 700 900 1000 0 80.59 82.72 83.40 83.62 83.79 83.90 83.98 84.01 0.1 81.75 83.21 83.63 83.79 83.88 83.98 84.03 84.05 1 83.58 33.90 83.99 84.04 84.08 84.12 84.14 84.15 5 84.00 84.09 84.13 84.16 84.17 84.19 84.21 84.21

FIGS. 6A and 6B plot these example compression results, first directly as a function of the maximum block size and ramp input parameters and then as a function of the number of unique pairs present in the blocks. The former shows that the approach to the maximum compression value is asymptotic for the various ramp conditions. It appears that we have reached a maximum compression value of 84.21 for the most liberal settings, which all yield around 5.3 million unique pairs. The FIG. 6B graph illustrates that compression is a linear function of the number of unique pairs considered. The ramp factor affects this function primarily via the fact that higher ramps give rise to more unique pairs. However, the ramp factor can also be used to control the number of iterations required to explore the space.

FIG. 7 shows the number of correct-sized blocks discovered in each iteration for the different ramp conditions, where iteration zero is top-level blocking. The higher ramp factors can improve the performance of blocking procedure by discovering more correctly-sized blocks in the earlier iterations.

While the technology herein has been described in connection with exemplary illustrative non-limiting embodiments, the invention is not to be limited by the disclosure. For example, while MapReduce is used in the example non-limiting implementation, other parallel or other computing platforms are also possible. The invention is intended to be defined by the claims and to cover all corresponding and equivalent arrangements whether or not specifically disclosed herein. 

We claim:
 1. A method of using a plurality of distributed computing nodes each comprising a processor and associated storage to dynamically block, comprising: (a) grouping together records of a data set with similar properties into blocks; and (b) for a block that is intractably large and therefore requires further blocking, automatically discovering based on the contents of the intractably large block, sets of shared properties that enable creation of sub-blocks of tractable size.
 2. The method of claim 1 wherein automatically discovering comprises automatically analyzing the set of properties present in records in an oversized block to dynamically guide subdivision of that oversized block.
 3. The method of claim 1 further including processing the discovered sets of shared record properties in parallel using the plurality of distributed computing nodes to recursively or iteratively subdivide or partition, based on similar properties, at least one intractably large block into blocks of tractable size.
 4. The method of claim 1 further including dynamically adjusting the discovered sets of shared properties in response to the composition of the data set and block size.
 5. The method of claim 1 wherein the data set comprises a massive database of personal information from diverse data sources for an online people search.
 6. The method of claim 1 wherein discovering applies a ramp parameter by which the maximum number of comparisons in the block of intractable size is increased with each recursion or iteration to provide a data-driven way to trade off between sub-blocking and linkage.
 7. The method of claim 1 further including allowing sets of records to overlap.
 8. The method of claim 1 further including applying the method to data sets when there is no obvious quickly-calculable metric between records and the number of records makes even a fast calculation for all pairs intractable.
 9. The method of claim 1 further including creating multiple top-level blocks that can be worked on independently and in parallel.
 10. The method of claim 1 further including dynamically adjusting the creation of sub-blocks based on several record property dimensions along which the records may vary, thereby avoiding the need to define a single ordering that places similar records next to each other.
 11. The method of claim 1 further including allowing maximum block size to be a function of block key length.
 12. A system for dynamically blocking comprising: a plurality of distributed computing nodes each comprising a processor and associated non-transitory memory, the nodes each storing in non-transitory storage codes that when executed in parallel: groups together records of a data set with similar properties into blocks; and for a block that is intractably large and therefore requires further blocking, automatically discovers based on the contents of the intractably large block, sets of shared properties that enable creation of sub-blocks of tractable size.
 13. The system of claim 12 wherein the code automatically analyzes the set of properties present in records in an oversized block to dynamically guide subdivision into sub-blocks.
 14. The system of claim 12 wherein the processors process the discovered sets of shared record properties in parallel to recursively or iteratively subdivide or partition, based on similar properties, at least one intractably large block into blocks of tractable size.
 15. The system of claim 12 wherein the processors dynamically adjust the discovered sets of shared properties in response to the composition of the data set and block size.
 16. The system of claim 12 wherein the data set comprises a massive database of personal information from diverse data sources for an online people search.
 17. The system of claim 12 wherein the processors apply a ramp parameter by which the maximum number of comparisons in the block of intractable size is increased with each recursion or iteration to provide a data-driven way to trade off between sub-blocking and linkage.
 18. The system of claim 12 wherein the processors allow sets of records to overlap.
 19. The system of claim 12 wherein the processors apply reduction to data sets when there is no obvious quickly-calculable metric between records and the number of records makes even a fast calculation for all pairs intractable.
 20. The system of claim 12 wherein the processors create multiple top-level blocks that can be worked on independently and in parallel.
 21. The system of claim 12 wherein the processors dynamically adjust the creation of sub-blocks based on several record property dimensions along which the records may vary, thereby avoiding the need to define a single ordering that places similar records next to each other.
 22. The system of claim 12 further including allowing maximum block size to be a function of block key length. 